package LinkedList;

public class a {
    public static void main(String[] args) {
        /**
         * 测试
         * 先创建节点
         */
        HeroNode heroNode1 = new HeroNode(1, "松江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2, "卢俊义", "date2");
        HeroNode heroNode3 = new HeroNode(3, "无用", "date3");
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.add(heroNode1);
        singleLinkedList.add(heroNode2);
        singleLinkedList.add(heroNode3);
        SingleLinkedList singleLinkedList1 = ReverseLinkedList(singleLinkedList);
        singleLinkedList1.list();


    }
    public static SingleLinkedList ReverseLinkedList(SingleLinkedList singleLinkedList){
        HeroNode ReverseNode = new HeroNode(0, "", "");
        HeroNode cur = singleLinkedList.getHead().next;
        if (cur==null||cur.next==null){
            return null;
        }
      HeroNode next;
      while (cur!=null){
          next=cur.next;
          //两个指针不能指向同一个 不能是next.next=cur || n
          
          cur.next=ReverseNode.next;
          ReverseNode.next=cur;
        cur=next;
      }
      singleLinkedList.getHead().next=ReverseNode.next;
        return singleLinkedList;
    }

   /* public static SingleLinkedList reverseLinked(SingleLinkedList singleLinkedList){

        HeroNode cur=singleLinkedList.getHead().next;
        if (cur==null||cur.next==null){
            return null;
        }
         HeroNode next=null;
        HeroNode reverseHead=new HeroNode(0,"","");
        while (cur!=null){
            next=cur.next;
            cur.next=reverseHead.next;
            reverseHead.next=cur;
            cur=next;
        }
        singleLinkedList.getHead().next=reverseHead.next;
return  singleLinkedList;
    }*/

    /**
     * 获取有效长度 遍历即可
     * @param singleLinkedList
     * @return
     */

    public static int getLength(SingleLinkedList singleLinkedList){
        //辅助变量
        HeroNode temp = singleLinkedList.getHead();
        //不能直接 把head 遍历  因为会改变这个的值 head用来赋值就行了
        HeroNode cur=temp.next;

        if (cur==null){
            System.out.println("链表为空");
            return 0;
        }
        int length=0;
        while (cur!=null){
            length++;
            cur=cur.next;
        }
        return length;
    }


    public static HeroNode findLastDode(SingleLinkedList singleLinkedList,int index){
        if (singleLinkedList.getHead().next==null){
            return  null;
        }
        int size=getLength(singleLinkedList);
        if (index<=0||index>size){
            return null;
        }
        HeroNode cur=singleLinkedList.getHead().next;
        for (int i=0; i<size-index;i++){
            cur=cur.next;
        }
        return cur;
    }
}


/**
 * 这个就是LinkedList 由node 组成
 */
class SingleLinkedList {
    private HeroNode head = new HeroNode(0, "", "");

    public HeroNode getHead() {
        return head;
    }

    //先初始化一个头结点，头结点不要动 ,不放具体的数据
    //不考虑链表顺序时
    // 添加结点到链表 添加的时候最重要的是找到链表的最后 让最后的next 指向 新的结点
    public void add(HeroNode heroNode) {
        //因为head节点不能动，因此需要一个辅助遍历temp
        HeroNode temp = head;//相当于有个temp指向 了head
        //遍历链表 ，找到最后
        while (true) {
            //当temp.next==null
            if (temp.next == null) {
                break;
            }
            //没找到 temp后移 temp.next就是一个节点对象 可以用来储存节点 当链表是空的时候 temp.next也是空的 所以可以直接添加
            //
            temp = temp.next;
        }
        //退出While循环的时候 temp 就指向了最后 开始直接添加  让temp.next 指向新的结点
        temp.next = heroNode;

    }

    //显示链表 （遍历） 通过一个辅助变量来遍历
    public void list() {
        //判断链表为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //定义辅助变量
        HeroNode temp = head.next;
        while (true) {
            //判断是否到了最后
            if (temp == null) {
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //temp后移 直到退出循环 写完了
            temp = temp.next;
        }
    }

    public void addByOrder(HeroNode heroNode) {
        //辅助指针
        HeroNode temp = head;
        boolean flag = false;// 标志  表示添加的编号是否存在
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > heroNode.no) {//当前temp的next大于要插入的值了 说明此时可以在temp 后添加数据
                break;
            } else if (temp.next.no == heroNode.no) {
                flag = true;
            }
            temp = temp.next;//相当于temp的 身份 被链表传递 也是退出循环的条件
        }
        if (flag) {
            //后移以后第一件事就是判断是不是已经存在
            System.out.println("编号已经存在");
        } else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    public void update(HeroNode newHeroNode) {
        Boolean flag = false;
        if (head.next == null) {
            System.out.println("链表为空");
        }
        /**
         * 找到要修改的节点
         */
        //这个辅助节点等于head.next和等于head都不碍事 添加的时候等于head是因为不一定有next 但是这个之前已经判断了是不是空了

        HeroNode temp = head.next;
        while (true) {
            if (temp.next == null) {

                break;//遍历完毕
            }
            if (temp.no == newHeroNode.no) {
                flag = true;
            }
            temp = temp.next;
        }
        //根据flag判断是否找到节点
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        } else {
            System.out.println("没有找到");
        }

    }

    public void delete(HeroNode newHeroNode) {
        Boolean flag = false;
        //判断链表为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //定义辅助变量

        HeroNode temp = head;
        while (true) {
            if (temp.next == null) {

                break;//遍历完毕
            }
            if (temp.next.no == newHeroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.next=temp.next.next;
        }else {
            System.out.println("没找到");
        }

    }



}



/**
 * 定义一个HeroNode，每个HeroNode对象就是一个节点
 */
class HeroNode {
    int no;
    String name;
    String nickName;
    //指针指向下一个节点
    public HeroNode next;

    public HeroNode(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' + ",next=" + next +
                '}';
    }
}